Caricamento delle librerie
import os
import pandas as pd
from numpy import loadtxt
import numpy as np
import datetime
import tensorflow as tf
import matplotlib.pyplot as plt
from sklearn.preprocessing import MinMaxScaler
import time
# For LSTM model
from keras.models import Sequential
from keras.layers import Dense
from keras.layers import LSTM
from keras.layers import Dropout
from keras.callbacks import EarlyStopping
from keras.models import load_model
#from ann_visualizer.visualize import ann_viz
from keras.utils.vis_utils import plot_model
import plotly.graph_objects as go
import plotly.express as px
import plotly.io as pio
# Themes
# "seaborn", 'ggplot2', 'seaborn', 'simple_white', 'plotly', 'plotly_white', 'plotly_dark', 'presentation', 'xgridoff', 'ygridoff', 'gridon', 'none'
pio.templates.default = "presentation"
from plotly.subplots import make_subplots
Seleziona cartelle e carica file
# select data folder_dati
glob_path = os.path.normpath(os.getcwd() + os.sep + os.pardir)
folder_dati = glob_path+R"//dati"
folder_risultati = glob_path+R"//risultati"
files = os.listdir(folder_risultati)
files[0:]
# Load df_grouped_date, original file
df = pd.read_csv(folder_risultati+"/df_grouped_date_nosunday.csv", sep = ",")
df2 = pd.read_csv(folder_risultati+"/df_min_ciclo_nosunday_no0.csv", sep = ",")
df = df2
# substitute null values with 0
df['Minuti ciclo'] = df['Minuti ciclo'].fillna(0)
#df['Minuti NO ciclo'] = df['Minuti NO ciclo'].fillna(0)
#df['Efficienza'] = df['Efficienza'].fillna(0)
# convert Date
df['Date'] = pd.to_datetime(df["Date"], format='%Y-%m-%d')
# convert minuti ciclo, no ciclo, efficienza to double
df['Minuti ciclo'] = df['Minuti ciclo'].replace(',', '.', regex=True).astype(float)
#df['Minuti NO ciclo'] = df['Minuti NO ciclo'].replace(',', '.', regex=True).astype(float)
#df['Efficienza'] = df['Efficienza'].replace(',', '.', regex=True).astype(float)
df
# plot general efficiency
fig = px.line(df, x = "Date", y = "Minuti ciclo",
title = "Efficienza / giorno Totale delle macchine")
fig.show()
Seleziona train e test
train = df[:313]
# Scale features
s1 = MinMaxScaler(feature_range=(-1,1))
Xs = s1.fit_transform(train[['Minuti ciclo']])
# Scale predicted value
s2 = MinMaxScaler(feature_range=(-1,1))
Ys = s2.fit_transform(train[['Minuti ciclo']])
Usa una finestra di osservazioni di 7 giorni per far girare la rete neurale
# Each time step uses last 'window' to predict the next change
window = 6
X = []
Y = []
for i in range(window,len(Xs)):
X.append(Xs[i-window:i,:])
Y.append(Ys[i])
# Reshape data to format accepted by LSTM
X, Y = np.array(X), np.array(Y)
Crea il modello e lo alleni
# create and train LSTM model
# Initialize LSTM model
model1 = Sequential()
model1.add(LSTM(units=50, return_sequences=True, \
input_shape=(X.shape[1],X.shape[2])))
model1.add(Dropout(0.2))
model1.add(LSTM(units=50, return_sequences=True))
model1.add(Dropout(0.2))
model1.add(LSTM(units=50))
model1.add(Dropout(0.2))
model1.add(Dense(units=1))
model1.compile(optimizer = 'adam', loss = 'mean_squared_error',\
metrics = ['accuracy'])
# Allow for early exit
es = EarlyStopping(monitor='loss',mode='min',verbose=1,patience=10)
# Fit (and time) LSTM model
t0 = time.time()
history = model1.fit(X, Y, epochs = 20, batch_size = 250, callbacks=[es], verbose=1)
t1 = time.time()
print('Runtime: %.2f s' %(t1-t0))
# Plot loss
plt.figure(figsize=(20,4))
plt.semilogy(history.history['loss'])
plt.xlabel('epoch'); plt.ylabel('loss')
# Verify the fit of the model
Yp = model1.predict(X)
# un-scale outputs
Yu = s2.inverse_transform(Yp)
Ym = s2.inverse_transform(Y)
plt.figure(figsize=(20,6))
plt.subplot(1,1,1)
plt.plot(train['Date'][window:],Yu,'r-',label='LSTM')
plt.plot(train['Date'][window:],Ym,'k--',label='Real')
plt.ylabel('Minuti ciclo')
plt.legend()
# RMSE on train
from sklearn.metrics import mean_squared_error
from math import sqrt
rmse1_train = sqrt(mean_squared_error(Ym, Yu))
rmse1_train
# Load model
v = model1
# Load testing data
test = df[313:497]
Xt = test[['Minuti ciclo']].values
Yt = test[['Minuti ciclo']].values
Xts = s1.transform(Xt)
Yts = s2.transform(Yt)
Xti = []
Yti = []
for i in range(window,len(Xts)):
Xti.append(Xts[i-window:i,:])
Yti.append(Yts[i])
# Reshape data to format accepted by LSTM
Xti, Yti = np.array(Xti), np.array(Yti)
# Verify the fit of the model
Ytp = model.predict(Xti)
# un-scale outputs
Ytu = s2.inverse_transform(Ytp) # predicted
Ytm = s2.inverse_transform(Yti) # real
plt.figure(figsize=(20,6))
plt.subplot(1,1,1)
plt.plot(test['Date'][window:],Ytu,'r-',label='LSTM Predicted')
plt.plot(test['Date'][window:],Ytm,'k--',label='Real')
plt.legend()
plt.ylabel('Minuti ciclo')
Ytu
Calcola indice RMSE
from sklearn.metrics import mean_squared_error
from math import sqrt
pred = Ytu[:201]
real = Ytm[:201]
rmse1_test = sqrt(mean_squared_error(real, pred))
rmse1_test
plot_model(model, to_file='model_plot.png', show_shapes=True, show_layer_names=True)
# second structure
# Initialize LSTM model
model2 = Sequential()
model2.add(LSTM(units=50, return_sequences=True, \
input_shape=(X.shape[1],X.shape[2])))
model2.add(Dropout(0.2))
model2.add(LSTM(units=30))
model2.add(Dropout(0.2))
model2.add(Dense(units=1))
model2.compile(optimizer = 'adam', loss = 'mean_squared_error',\
metrics = ['accuracy'])
# Allow for early exit
es = EarlyStopping(monitor='loss',mode='min',verbose=1,patience=10)
# Fit (and time) LSTM model
t0 = time.time()
history = model2.fit(X, Y, epochs = 20, batch_size = 250, callbacks=[es], verbose=1)
t1 = time.time()
print('Runtime: %.2f s' %(t1-t0))
# Plot loss
plt.figure(figsize=(20,4))
plt.semilogy(history.history['loss'])
plt.xlabel('epoch'); plt.ylabel('loss')
# Verify the fit of the model
Yp = model2.predict(X)
# un-scale outputs
Yu = s2.inverse_transform(Yp)
Ym = s2.inverse_transform(Y)
plt.figure(figsize=(20,6))
plt.subplot(1,1,1)
plt.plot(train['Date'][window:],Yu,'r-',label='LSTM')
plt.plot(train['Date'][window:],Ym,'k--',label='Real')
plt.ylabel('Minuti ciclo')
plt.legend()
# RMSE on train
from sklearn.metrics import mean_squared_error
from math import sqrt
rmse2_train = sqrt(mean_squared_error(Ym, Yu))
rmse2_train
# Load model
v = model2
# Load testing data
test = df[313:497]
Xt = test[['Minuti ciclo']].values
Yt = test[['Minuti ciclo']].values
Xts = s1.transform(Xt)
Yts = s2.transform(Yt)
Xti = []
Yti = []
for i in range(window,len(Xts)):
Xti.append(Xts[i-window:i,:])
Yti.append(Yts[i])
# Reshape data to format accepted by LSTM
Xti, Yti = np.array(Xti), np.array(Yti)
# Verify the fit of the model
Ytp = model2.predict(Xti)
# un-scale outputs
Ytu = s2.inverse_transform(Ytp) # predicted
Ytm = s2.inverse_transform(Yti) # real
plt.figure(figsize=(20,6))
plt.subplot(1,1,1)
plt.plot(test['Date'][window:],Ytu,'r-',label='LSTM Predicted')
plt.plot(test['Date'][window:],Ytm,'k--',label='Real')
plt.legend()
plt.ylabel('Minuti ciclo')
from sklearn.metrics import mean_squared_error
from math import sqrt
pred = Ytu[:201]
real = Ytm[:201]
rmse2_test = sqrt(mean_squared_error(real, pred))
rmse2_test
plot_model(model2, to_file='model_plot.png', show_shapes=True, show_layer_names=True)
# third structure
# Initialize LSTM model
model3 = Sequential()
model3.add(LSTM(units=50, return_sequences=True, \
input_shape=(X.shape[1],X.shape[2])))
model3.add(Dropout(0.2))
model3.add(LSTM(units=50, return_sequences=True))
model3.add(Dropout(0.2))
model3.add(LSTM(units=40, return_sequences=True))
model3.add(Dropout(0.2))
model3.add(LSTM(units=40))
model3.add(Dropout(0.2))
model3.add(Dense(units=1))
model3.compile(optimizer = 'adam', loss = 'mean_squared_error',\
metrics = ['accuracy'])
# Allow for early exit
es = EarlyStopping(monitor='loss',mode='min',verbose=1,patience=10)
# Fit (and time) LSTM model
t0 = time.time()
history = model3.fit(X, Y, epochs = 20, batch_size = 250, callbacks=[es], verbose=1)
t1 = time.time()
print('Runtime: %.2f s' %(t1-t0))
# Plot loss
plt.figure(figsize=(20,4))
plt.semilogy(history.history['loss'])
plt.xlabel('epoch'); plt.ylabel('loss')
# Verify the fit of the model
Yp = model3.predict(X)
# un-scale outputs
Yu = s2.inverse_transform(Yp)
Ym = s2.inverse_transform(Y)
plt.figure(figsize=(20,6))
plt.subplot(1,1,1)
plt.plot(train['Date'][window:],Yu,'r-',label='LSTM')
plt.plot(train['Date'][window:],Ym,'k--',label='Real')
plt.ylabel('Minuti ciclo')
plt.legend()
# RMSE on train
from sklearn.metrics import mean_squared_error
from math import sqrt
rmse3_train = sqrt(mean_squared_error(Ym, Yu))
rmse3_train
# Load model
v = model3
# Load testing data
test = df[313:497]
Xt = test[['Minuti ciclo']].values
Yt = test[['Minuti ciclo']].values
Xts = s1.transform(Xt)
Yts = s2.transform(Yt)
Xti = []
Yti = []
for i in range(window,len(Xts)):
Xti.append(Xts[i-window:i,:])
Yti.append(Yts[i])
# Reshape data to format accepted by LSTM
Xti, Yti = np.array(Xti), np.array(Yti)
# Verify the fit of the model
Ytp = model3.predict(Xti)
# un-scale outputs
Ytu = s2.inverse_transform(Ytp) # predicted
Ytm = s2.inverse_transform(Yti) # real
plt.figure(figsize=(20,6))
plt.subplot(1,1,1)
plt.plot(test['Date'][window:],Ytu,'r-',label='LSTM Predicted')
plt.plot(test['Date'][window:],Ytm,'k--',label='Real')
plt.legend()
plt.ylabel('Minuti ciclo')
from sklearn.metrics import mean_squared_error
from math import sqrt
pred = Ytu[:201]
real = Ytm[:201]
rmse3_test = sqrt(mean_squared_error(real, pred))
rmse3_test
plot_model(model3, to_file='model_plot.png', show_shapes=True, show_layer_names=True)
# 4 structure
# Initialize LSTM model
model4 = Sequential()
model4.add(LSTM(units=50, return_sequences=True, \
input_shape=(X.shape[1],X.shape[2])))
model4.add(Dropout(0.2))
model4.add(LSTM(units=50, return_sequences=True))
model4.add(Dropout(0.2))
model4.add(LSTM(units=40, return_sequences=True))
model4.add(Dropout(0.2))
model4.add(LSTM(units=40))
model4.add(Dropout(0.2))
model4.add(Dense(units=1))
model4.compile(optimizer = 'adam', loss = 'mean_squared_error',\
metrics = ['accuracy'])
# Allow for early exit
es = EarlyStopping(monitor='loss',mode='min',verbose=1,patience=10)
# Fit (and time) LSTM model
t0 = time.time()
history = model4.fit(X, Y, epochs = 50, batch_size = 250, callbacks=[es], verbose=1)
t1 = time.time()
print('Runtime: %.2f s' %(t1-t0))
# Plot loss
plt.figure(figsize=(20,4))
plt.semilogy(history.history['loss'])
plt.xlabel('epoch'); plt.ylabel('loss')
# Verify the fit of the model
Yp = model4.predict(X)
# un-scale outputs
Yu = s2.inverse_transform(Yp)
Ym = s2.inverse_transform(Y)
plt.figure(figsize=(20,6))
plt.subplot(1,1,1)
plt.plot(train['Date'][window:],Yu,'r-',label='LSTM')
plt.plot(train['Date'][window:],Ym,'k--',label='Real')
plt.ylabel('Minuti ciclo')
plt.legend()
# RMSE on train
from sklearn.metrics import mean_squared_error
from math import sqrt
rmse4_train = sqrt(mean_squared_error(Ym, Yu))
rmse4_train
# Load model
v = model4
# Load testing data
test = df[313:497]
Xt = test[['Minuti ciclo']].values
Yt = test[['Minuti ciclo']].values
Xts = s1.transform(Xt)
Yts = s2.transform(Yt)
Xti = []
Yti = []
for i in range(window,len(Xts)):
Xti.append(Xts[i-window:i,:])
Yti.append(Yts[i])
# Reshape data to format accepted by LSTM
Xti, Yti = np.array(Xti), np.array(Yti)
# Verify the fit of the model
Ytp = model4.predict(Xti)
# un-scale outputs
Ytu = s2.inverse_transform(Ytp) # predicted
Ytm = s2.inverse_transform(Yti) # real
plt.figure(figsize=(20,6))
plt.subplot(1,1,1)
plt.plot(test['Date'][window:],Ytu,'r-',label='LSTM Predicted')
plt.plot(test['Date'][window:],Ytm,'k--',label='Real')
plt.legend()
plt.ylabel('Minuti ciclo')
from sklearn.metrics import mean_squared_error
from math import sqrt
pred = Ytu[:201]
real = Ytm[:201]
rmse4_test = sqrt(mean_squared_error(real, pred))
rmse4_test
plot_model(model4, to_file='model_plot.png', show_shapes=True, show_layer_names=True)
print(rmse1_train, rmse1_test, rmse2_train, rmse2_test, rmse3_train, rmse3_test, rmse4_train, rmse4_test)